home *** CD-ROM | disk | FTP | other *** search
/ START Magazine / START VOL 3 NO 7.st / KAMIKAZE.ARC / KAMIKAZE.C < prev    next >
Encoding:
C/C++ Source or Header  |  1988-11-14  |  11.4 KB  |  588 lines
  1.  
  2. /***  Kamikaze Chess
  3.  
  4.       Copyright 1988 Jim Kent
  5.  
  6.       February, 1989 START Magazine 
  7.  
  8.  
  9. ***/
  10.  
  11. #include "kamikaze.h"
  12.  
  13. #define NOMOVE NULL
  14. #define SQSZX 28
  15. #define SQSZY 24 
  16. #define MXOFF (9+SQSZX*8)
  17.  
  18. extern Piece white_pieces[16], black_pieces[16], w_pieces[16], b_pieces[16];
  19.  
  20. extern unsigned WORD
  21.     iwhite_pawn[], iwhite_knight[], iwhite_bishop[], iwhite_rook[], 
  22.     iwhite_queen[], iwhite_king[],
  23.     iblack_pawn[], iblack_knight[], iblack_bishop[], iblack_rook[], 
  24.     iblack_queen[], iblack_king[];
  25. extern check_pawn();
  26.  
  27. extern WORD randseed;
  28.  
  29. extern Piece_move bpawn_moves[4], wpawn_moves[4];
  30.  
  31.  
  32. WORD break_game;    /* done with game (pressed 'q') ? */
  33. WORD curx, cury;    /* cursor position for keyboard control */
  34.  
  35. /* convert a promoted pawn back to a pawn */
  36. repawn(p)
  37. register Piece *p;
  38. {
  39. p->type = PAWN;
  40. p->name = "Pn";
  41. if (p->color == BLACK)
  42.     {
  43.     p->image = iblack_pawn;
  44.     p->lmoves = bpawn_moves;
  45.     }
  46. else
  47.     {
  48.     p->image = iwhite_pawn;
  49.     p->lmoves = wpawn_moves;
  50.     }
  51. p->legal = check_pawn;
  52. p->lmove_count = Array_els(bpawn_moves);
  53. }
  54.  
  55. /* promote a pawn to a new type */
  56. retype_piece(p, piece_ix)
  57. register Piece *p;
  58. int piece_ix;
  59. {
  60. register Piece *qp;
  61.  
  62. qp = pieces[p->color]+piece_ix;
  63. p->type = qp->type;
  64. p->name = qp->name;
  65. p->image = qp->image;
  66. p->legal = qp->legal;
  67. p->lmoves = qp->lmoves;
  68. p->lmove_count = qp->lmove_count;
  69. p->value = qp->value;
  70. }
  71.  
  72. /* Fill in the xy locations of the squares of board and their colors. */
  73. init_board()
  74. {
  75. extern ushort move_count;
  76. extern int living[2];
  77. extern WORD move_color;
  78. int i, j;
  79. register int color;
  80. register Square *b;
  81.  
  82. color = 1;
  83. for (i=0; i<8; i++)
  84.     {
  85.     for (j=0; j<8; j++)
  86.         {
  87.         b = &(board[i][j]);
  88.         b->x = 2+SQSZX*j+1;
  89.         b->y = 2+SQSZY*i+1;
  90.         b->width = SQSZX;
  91.         b->height = SQSZY;
  92.         b->color = (color&1);
  93.         b->piece = NULL;
  94.         color += 1;
  95.         }
  96.     color += 1;
  97.     }
  98. }
  99.  
  100. /* Draw a single square of chess board, and the piece on it if any */
  101. draw_square(sq)
  102. register Square *sq;
  103. {
  104. register Piece *p;
  105.  
  106. colored_block(sq->color, sq->x, sq->y, sq->width, sq->height);
  107. if (p = sq->piece)
  108.     {
  109.     show_piece(p->image, sq->x, sq->y, p->color+2);
  110.     }
  111. }
  112.  
  113. /* Given a piece draw the square its on. */
  114. draw_psquare(p)
  115. struct piece *p;
  116. {
  117. draw_square(&board[p->row][p->column]);
  118. }
  119.  
  120. /* Draw the whole board */
  121. draw_board()
  122. {
  123. int i;
  124. register Square *sq;
  125.  
  126. vswr_mode(handle, 2);
  127. /* Draw the outline around chess squares */
  128. colored_block(1, 1, 1, MXOFF-6, 1);
  129. colored_block(1, 1, YMAX-4, MXOFF-6, 1);
  130. colored_block(1, 1, 1, 1, YMAX-4);
  131. colored_block(1, MXOFF-5, 1, 1, YMAX-4);
  132. /* and the squares themselves */
  133. sq = &board[0][0];
  134. i = 8*8;
  135. while (--i >= 0)
  136.     {
  137.     draw_square(sq);
  138.     sq++;
  139.     }
  140. }
  141.  
  142.  
  143.  
  144. /* short line of text on top right */
  145. short_message(c, color)
  146. char *c;
  147. int color;
  148. {
  149. smessage(c, color, 0);
  150. }
  151.  
  152. /* Message on 2nd line of right side */
  153. message2(c, color)
  154. char *c;
  155. int color;
  156. {
  157. smessage(c, color, 1);
  158. }
  159.  
  160. /* A short line of text on the right.  Y is vertical location from 0-19 */
  161. smessage(c, color, y)
  162. char *c;
  163. int color;
  164. int y;
  165. {
  166. y*=10;
  167. y += 1;
  168. hide_mouse();
  169. colored_block(0, 6+SQSZX*8, y, XMAX-(6+SQSZX*8), 10);
  170. gtext(c, MXOFF-2, y, color);
  171. show_mouse();
  172. }
  173.  
  174.  
  175. /* Put the pieces on the board */
  176. init_pieces(p)
  177. register Piece *p;
  178. {
  179. int i;
  180.  
  181. i = 16;
  182. while (--i >= 0)
  183.     {
  184.     board[p->row][p->column].piece = p;
  185.     p++;
  186.     }
  187. }
  188.  
  189.  
  190. /* Figure out which square the mouse is over */
  191. find_square()
  192. {
  193. curx = (mouse_x - board[0][0].x) / board[0][0].width;
  194. cury = (mouse_y - board[0][0].y) / board[0][0].height;
  195. return(curx <= 7 && curx >= 0 && cury <= 7 && cury >= 0);
  196. }
  197.  
  198. /* Xor a square to hilight it and show user where he is */
  199. xor_sq(sq)
  200. register Square *sq;
  201. {
  202. xor_block(15, sq->x, sq->y, sq->width, sq->height);
  203. }
  204.  
  205. /* Draw a red frame around square to show that's what piece is being
  206.    moved. */
  207. frame_square(sq)
  208. register Square *sq;
  209. {
  210. colored_block(5, sq->x, sq->y, 1, sq->height);
  211. colored_block(5, sq->x+sq->width-1, sq->y, 1, sq->height);
  212. colored_block(5, sq->x, sq->y, sq->width, 1);
  213. colored_block(5, sq->x, sq->y+sq->height-1, sq->width, 1);
  214. }
  215.  
  216. /* Flash 2 pieces, perhaps to show that 'you must take' this with that. */
  217. flash_pieces(p1, p2)
  218. struct piece *p1, *p2;
  219. {
  220. fpieces(p1, p2, 4);
  221. }
  222.  
  223. fpieces(p1, p2, i)
  224. struct piece *p1, *p2;
  225. int i;
  226. {
  227.  
  228. hide_mouse();
  229. while (--i >= 0)
  230.     {
  231.     xor_sq(&board[p1->row][p1->column]);
  232.     if (p2 != NULL)
  233.         xor_sq(&board[p2->row][p2->column]);
  234.     wait_a_jiffy(20);
  235.     }
  236. show_mouse();
  237. }
  238.  
  239. /* Move a piece using the mouse */
  240. mouse_move_piece(color)
  241. int color;
  242. {
  243. Square *sq, *newsq, *lastsq;
  244. register Piece *p;
  245.  
  246. if (!find_square())
  247.     {
  248.     return(0);
  249.     }
  250. lastsq = newsq = sq = &board[cury][curx];
  251. if ((p = sq->piece) == NULL)
  252.     {
  253.     return(0);
  254.     }
  255. if (p->color != color)
  256.     {
  257.     return(0);
  258.     }
  259. hide_mouse();
  260. frame_square(sq);
  261. xor_sq(newsq);
  262. show_mouse();
  263. for (;;)
  264.     {
  265.     check_input();
  266.     if (mouse_moved)
  267.         {
  268.         if (find_square())
  269.             {
  270.             newsq = &board[cury][curx];
  271.             if (lastsq != newsq)
  272.                 {
  273.                 hide_mouse();
  274.                 xor_sq(lastsq);
  275.                 xor_sq(newsq);
  276.                 show_mouse();
  277.                 lastsq = newsq;
  278.                 }
  279.             }
  280.         }
  281.     if (!PDN)
  282.         break;
  283.     }
  284. hide_mouse();
  285. xor_sq(newsq);
  286. draw_square(sq);
  287. show_mouse();
  288. return(move_piece(p, curx, cury));
  289. }
  290.  
  291.  
  292. /* Move the 'chess square cursor' in response to the arrow keys */
  293. key_move_cur()
  294. {
  295. hide_mouse();
  296. xor_sq(&board[cury][curx]);
  297. switch (key_in)
  298.     {
  299.     case LARROW:    /* left arrow */
  300.         if (curx > 0)
  301.             curx -= 1;
  302.         break;
  303.     case RARROW:    /* right arrow */
  304.         if (curx < 7)
  305.             curx += 1;
  306.         break;
  307.     case DARROW: /* down arrow */
  308.         if (cury < 7)
  309.             cury += 1;
  310.         break;
  311.     case UARROW: /* up arrow */
  312.         if (cury > 0)
  313.             cury -= 1;
  314.         break;
  315.     }
  316. xor_sq(&board[cury][curx]);
  317. show_mouse();
  318. }
  319.  
  320. /* Let user select a square with keyboard. */
  321. kfind_square()
  322. {
  323. for (;;)
  324.     {
  325.     check_input();
  326.     if (key_hit)
  327.         {
  328.         switch (key_in&0xff)
  329.             {
  330.             case '\r':
  331.                 return(1);
  332.             case ' ':
  333.                 return(0);
  334.             case 'x':
  335.             case 'q':
  336.                 break_game = 1;
  337.                 return(0);
  338.             default:
  339.                 key_move_cur();
  340.                 break;
  341.             }
  342.         }
  343.     if (RJSTDN)
  344.         return(0);
  345.     }
  346. }
  347.  
  348. /* Hide mouse xor */
  349. hmxor()
  350. {
  351. hide_mouse();
  352. xor_sq(&board[cury][curx]);
  353. show_mouse();
  354. }
  355.  
  356.  
  357. /* Move a piece using the keyboard */
  358. key_move_piece(color)
  359. int color;
  360. {
  361. Square *sq;
  362. register Piece *p;
  363.  
  364. hmxor();
  365. if (!kfind_square())
  366.     {
  367.     hmxor();
  368.     return(0);
  369.     }
  370. sq = &board[cury][curx];
  371. hide_mouse();
  372. frame_square(sq);
  373. show_mouse();
  374. if ((p = sq->piece) == NULL)
  375.     {
  376.     hmxor();
  377.     hide_mouse();
  378.     draw_square(sq);
  379.     show_mouse();
  380.     return(0);
  381.     }
  382. if (p->color != color)
  383.     {
  384.     hmxor();
  385.     hide_mouse();
  386.     draw_square(sq);
  387.     show_mouse();
  388.     return(0);
  389.     }
  390. if (!kfind_square())
  391.     {
  392.     hmxor();
  393.     hide_mouse();
  394.     draw_square(sq);
  395.     show_mouse();
  396.     return(0);
  397.     }
  398. hmxor();
  399. hide_mouse();
  400. draw_square(sq);
  401. show_mouse();
  402. return(move_piece(p, curx, cury));
  403. }
  404.  
  405.  
  406. char *whomove[2] = {"White Move", "Black Move"};
  407. /* Ok it's a human player's turn.  Let them move with either keyboard or
  408.    mouse. */
  409. human_move_piece(color)
  410. WORD color;
  411. {
  412. for (;;)
  413.     {
  414.     check_input();
  415.     if (key_hit)
  416.         {
  417.         switch (key_in&0xff)
  418.             {
  419.             case 'x':
  420.             case 'q':
  421.                 outta_here();
  422.                 break;
  423.             case '\b':
  424.                 backup2();
  425.                 break;
  426.             default:
  427.                 if (key_move_piece(move_color))
  428.                     return;
  429.                 break;
  430.             }
  431.         }
  432.     if (PJSTDN)
  433.         {
  434.         if (mouse_move_piece(move_color))
  435.             return;
  436.         }
  437.     }
  438. }
  439.  
  440.  
  441. /* Somebody's moving.  ST parameter tells us whether it's man or machine. */
  442. some_move(st)
  443. int st;    /* st or human??? */
  444. {
  445. if (check_for_mate())
  446.     return(0);
  447. hide_mouse();
  448. if (st)
  449.     bee_cursor();
  450. else
  451.     {
  452.     if (move_color)
  453.         black_hand();
  454.     else
  455.         white_hand();
  456.     }
  457. show_mouse();
  458. short_message(whomove[move_color], move_color+2);
  459. if (st)
  460.     {
  461.     if (!droid_move_piece(move_color, 500L))
  462.         {
  463.         short_message("I'm confused", move_color+2);
  464.         return(0);    /* wierd error condition, "shouldn't" happen */
  465.         }
  466.     }
  467. else
  468.     human_move_piece(move_color);
  469. return(1);
  470. }
  471.  
  472. int wst, bst;    /* white and black played by ST ?? */
  473.  
  474. /* Put up that bunch of words to the right of the chessboard and
  475.     patiently wait for user(s) to tell us how they want to play this game. */
  476. do_menu()
  477. {
  478. int i;
  479.  
  480. /* draw up credits and menu options */
  481. big_font();
  482. italic_font();
  483. smessage("KAMI-",15,2);
  484. smessage("KAZE", 15, 4);
  485. smessage("CHESS", 15, 6);
  486. unitalic_font();
  487. small_font();
  488. smessage("COPYRIGHT 1988", 15, 8);
  489. smessage("JIM KENT", 15, 9);
  490. smessage("START MAGAZINE",15, 10);
  491. smessage("FEBRUARY 1989",15,11);
  492. smessage(" PLAY CHOICES:",15, 13);
  493. smessage("0  ST vs PLAYER", 15, 14);
  494. smessage("1  PLAYER vs ST", 15, 15);
  495. smessage("2  2 PLAYERS", 15, 16);
  496. smessage("3  ST vs ST", 15, 17);
  497. smessage("Q  QUIT", 15, 18);
  498. normal_font();
  499. hide_mouse();
  500. /* wait for user to hit the right key */
  501. for (;;)
  502.     {
  503.     check_input();
  504.     if (key_hit)
  505.         {
  506.         switch (key_in&0xff)
  507.             {
  508.             case '0':
  509.                 wst = 1;
  510.                 bst = 0;
  511.                 goto OUT;
  512.             case '1':
  513.                 wst = 0;
  514.                 bst = 1;
  515.                 goto OUT;
  516.             case '2':
  517.                 wst = 0;
  518.                 bst = 0;
  519.                 goto OUT;
  520.             case '3':
  521.                 wst = 1;
  522.                 bst = 1;
  523.                 goto OUT;
  524.             case 'q':
  525.             case 'Q':
  526.                 outta_here();
  527.             }
  528.         }
  529.     }
  530. OUT:
  531. /* erase menu part... */
  532. for (i=13; i<19; i++)
  533.     smessage("", 0, i);
  534. show_mouse();
  535. }
  536.  
  537.  
  538. do_a_game()
  539. {
  540. hide_mouse();        /* Micky go bye-bye while drawing on screen */
  541. clear_screen();        /* It all get's to be solid grey at first */
  542. move_color = WHITE;    /* White will move first */
  543. living[0] = living[1] = 16;    /* Both sides start with 16 pieces */
  544. move_count = 0;        /* And no moves yet... */
  545. init_board();
  546. copy_structure(w_pieces, white_pieces, sizeof(white_pieces) );
  547. copy_structure(b_pieces, black_pieces, sizeof(black_pieces) );
  548. init_pieces(white_pieces);
  549. init_pieces(black_pieces);
  550. draw_board();
  551. do_menu();
  552. randseed = time_peek();    /* initialize randomizer with time so not always same*/
  553. break_game = 0;
  554. for (;;)
  555.     {
  556.     if (!some_move(wst))
  557.         return;
  558.     if (break_game)
  559.         break;
  560.     if (!some_move(bst))
  561.         return;
  562.     if (break_game)
  563.         break;
  564.     }
  565. }
  566.  
  567.  
  568. /* Heya, let's bail.  Cleanup mess we've made and return control to
  569.    desktop or your favorite shell. */
  570. outta_here()
  571. {
  572. uninit_sys();
  573. exit(0);
  574. }
  575.  
  576. main()
  577. {
  578. if (init_sys()< 0)
  579.     outta_here();
  580. for (;;)
  581.     {
  582.     do_a_game();
  583.     }
  584. }
  585.  
  586.  
  587.  
  588.